home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / osr5 / sco / scripts / admin / ptyclean < prev    next >
Encoding:
AWK Script  |  1997-08-26  |  37.0 KB  |  1,063 lines
  1. #!/usr/local/bin/gawk -f
  2. #!/usr/bin/awk -f
  3. # @(#) ptyclean.gawk 1.2 96/05/07
  4. # 94/01/18 john h. dubois iii (john@armory.com)
  5. # 94/01/20 List ttys open before each process, in case the process has 
  6. #          dissociated from the tty but stillhas it open
  7. # 94/01/26 Added i option
  8. # 94/03/09 Use gawk so - options can be given
  9. # 94/03/21 Added p option.
  10. # 94/03/27 Added ptycleanrc, and print ps line before query.
  11. # 94/04/02 Added r option.
  12. # 94/06/23 Use crash to cut down on the number of ttys fuser has to check.
  13. # 94/10/23 Print full tty numbers as progress.
  14. # 94/10/27 More error checking.
  15. # 95/06/08 Make k, q, and i be independent and exclusive of each other.
  16. # 95/06/24 Use lsof for checking master ptys because it is much faster than
  17. #          fuser (but still considerably slower than crash, so continue using
  18. #          it too).  The plan is to also use lsof for finding processes using
  19. #          slave ptys.
  20. # 95/07/15 Added t option.
  21. # 96/05/07 SCO 5.0 port.
  22.  
  23. BEGIN {
  24.     Name = "ptyclean"
  25.     Usage = "Usage: " Name " [-hikpq]"
  26.     rcFile = "/etc/default/ptyclean"
  27.     Opts(Name,Usage,"qpkithx",0,rcFile,
  28.     "QUIET,PROGRESS,KILL,INTERACTIVE,TELL",0,"r")
  29.     if ("h" in Options) {
  30.     printf \
  31. "%s: List/kill processes running on ptys whose master side is not open.\n"\
  32. "%s\n"\
  33. "The default behaviour of %s is to list processes without killing them.\n"\
  34. "The i, k, and q options can be used to kill processes.\n"\
  35. "Options:\n"\
  36. "Some of these options may be set by putting variable names in the file\n"\
  37. "%s, one per line.  The variable names are given in\n"\
  38. "parentheses in the option descriptions.\n"\
  39. "-h: Print this help.\n"\
  40. "-i: Interactive; ask whether processes should be killed after listing\n"\
  41. "    them (INTERACTIVE).\n"\
  42. "-k: Kill all found processes without asking (KILL).\n"\
  43. "-q: Quiet kill; do not list processes, just kill them (QUIET).\n"\
  44. "-t: Tell what processes are found, and then exit without killing anything.\n"\
  45. "    This is the default.  -t can be used if the default has been changed\n"\
  46. "    in the %s file (TELL).\n"\
  47. "-p: Print the number of each pty checked, as a progress report (PROGRESS).\n"\
  48. "-r: Do not read the %s file.\n",
  49.     Name,Usage,Name,rcFile,rcFile,rcFile
  50.     exit 0
  51.     }
  52.     if ((ErrStr = ExclusiveOptions("i,k,q",Options)) != "") {
  53.     printf "%s: %s\n",Name,ErrStr > "/dev/stderr"
  54.     exit 1
  55.     }
  56.     Kill = "k" in Options || (Interactive = "i" in Options) ||
  57.     (Quiet = "q" in Options)
  58.     FS = "[: ]+"
  59.     Debug = "x" in Options
  60.     if ((maxpty = ChkPtys("p" in Options,Proc2TTYs)) < 0) {
  61.     if (!Quiet)
  62.         print "No pty orphans."
  63.     exit(0)
  64.     }
  65.     for (pid in Proc2TTYs)
  66.     ProcList = ProcList " " pid
  67.     if (!Quiet || Interactive) {
  68.     if (Kill && !Interactive)
  69.         print "Killing:" ProcList
  70.     else
  71.         print "Processes:" ProcList
  72.     # Do <ps -e> rather than <ps -t ttylist> because only 20 tty names
  73.     # can be given with -t.
  74.     # Make stdin be /dev/null to work around gawk+protlib bugs.
  75.     Cmd = "exec ps -ef < /dev/null"
  76.     if (Debug)
  77.         printf "Command: <%s>\n",Cmd
  78.     while ((ret = (Cmd | getline)) == 1) {
  79.         if ($1 == "")
  80.         pid = $3
  81.         else
  82.         pid = $2
  83.         if (pid in Proc2TTYs) {
  84.         print psLines[pid] = sprintf("%3s %s",Proc2TTYs[pid],$0)
  85.         ProcOrder[++POInd] = pid
  86.         }
  87.     }
  88.     if (ret == -1) {
  89.         printf "Command '%s' failed.  Exiting.\n",Cmd > "/dev/stderr"
  90.         exit 1
  91.     }
  92.     close(Cmd)
  93.     }
  94.     if (Interactive)
  95.     ProcList = AskProcs(POInd,ProcOrder,psLines)
  96.     if (Kill && ProcList != "")
  97.     system("kill -9 " ProcList)
  98. }
  99.  
  100. # ProcOrder[] contains process IDs, indexed 1..NumProcs.
  101. # psLines[] contains ps lines, index by pid.
  102. # The fate of each process is queried for.
  103. # A list of the pids to be killed is returned.
  104. function AskProcs(NumProcs,ProcOrder,psLines,  Kill,ProcList,i,pid,All) {
  105.     Kill = 1
  106.     All = 0
  107.     ProcList = ""
  108.     print \
  109. "Type y to kill proc, n or return to skip it, Y or N to kill or skip the rest:"
  110.     for (i = 1; i <= NumProcs; i++) {
  111.     pid = ProcOrder[i]
  112.     if (All)
  113.         ProcList = ProcList " " pid
  114.     else {
  115.         printf "%s: ",substr(psLines[pid],1,75)
  116.         if ((getline < "/dev/tty") == -1) {
  117.         printf "Read from /dev/tty failed.  Exiting.\n",Cmd \
  118.         > "/dev/stderr"
  119.         exit 1
  120.         }
  121.         if ($0 ~ /^y/)
  122.         ProcList = ProcList " " pid
  123.         else if ($0 ~ /^Y/) {
  124.         ProcList = ProcList " " pid
  125.         All = 1
  126.         }
  127.         else if ($0 ~ /^N/)
  128.         break
  129.     }
  130.     }
  131.     if (ProcList != "")
  132.     print "Killing:" ProcList
  133.     return ProcList
  134. }
  135.  
  136. function Proc_fuserLine(Progress) {
  137.     # Only pay attention to ptys with processes
  138.     if ($1 ~ /^[pt]typ/) {
  139.     ttynum = substr($1,5)+0 
  140.     if (NF > 1 && $2 ~ /[0-9]/)
  141.         return ttynum
  142.     else if (Progress && $1 ~ "^p")
  143.         printf "-%s",ttynum
  144.     }
  145.     return ""
  146. }
  147.  
  148. function Proc_lsofLine() {
  149.     # lsof output might or might not have leading /dev/
  150.     sub("^/dev/","",$NF)
  151.     if ($NF ~ "^[pt]typ")
  152.     return substr($NF,5)+0 
  153.     else {
  154.     if (Debug)
  155.         print "^^^ Non-file line returned by lsof"
  156.     return ""
  157.     }
  158. }
  159.  
  160. function FindttyProcs(ttyList,Use_lsof,Progress,
  161. pty,S,Cmd,ret,NumFound) {
  162.     
  163.     for (pty in ttyList)
  164.     S = S " ptyp" pty
  165.     Cmd = "cd /dev; exec " (Use_lsof ? "lsof -HOP" : "fuser") " " S " 2>&1"
  166.     if (Debug)
  167.     print ":" Cmd ":"
  168.     # Format returned by fuser:
  169.     #    ptyp0:    29592
  170.     # FS includes : so it will not be in $1
  171.     # Format returned by lsof:
  172. # telnetd    5056        0    3u   CHR    59,   0     0x13eb    706 /dev/ptyp0
  173.  
  174.     while ((ret = (Cmd | getline)) == 1) {
  175.     if (Debug)
  176.         print "\n" $0
  177.     if (Use_lsof)
  178.         ttynum = Proc_lsofLine()
  179.     else
  180.         ttynum = Proc_fuserLine(Progress)
  181.     if (Debug)
  182.         print "ttynum: " ttynum
  183.     if (ttynum != "" && ttynum in ttyList) {
  184.         # Remove slave of this pty from report; its master is open.
  185.         delete ttyList[ttynum]
  186.         NumFound++
  187.         if (Progress)
  188.         printf "+%s",ttynum
  189.     }
  190.     }
  191.     if (ret == -1) {
  192.     printf "Command '%s' failed.  Exiting.\n",Cmd > "/dev/stderr"
  193.     exit 1
  194.     }
  195.     close(Cmd)
  196.     if (Progress)
  197.     print ""
  198.     return NumFound
  199. }
  200.  
  201. # For each slave pty in use whose master side is not open, adds the tty to
  202. # Proc2TTYs.
  203. # Proc2TTYs[] is indexed by PID; the value is a comma separated list of ptys
  204. # numbers that that the process with that PID has open.
  205. # The number of the highest such tty is returned, or -1 if there are none.
  206.  
  207. # fuser is very slow, so crash is used to find only those ttyps that are open;
  208. # fuser is run on their masters, and then on only those whose master is not
  209. # open (to get proc list).  crash knows process group, but that isn't good
  210. # enough.
  211. function ChkPtys(Progress,Proc2TTYs,  
  212. Cmd,ttynum,maxpty,OpenPtys,pty,S,NumOpen,ret,Use_lsof)
  213. {
  214.     NumOpen = FindOpenPtySlaves(OpenPtys)
  215.     if (!Quiet)
  216.     printf "%d pty slave(s) open.\n",NumOpen
  217.     if (NumOpen == 0)
  218.     return -1
  219.     Cmd = "type lsof"
  220.     Cmd | getline
  221.     close(Cmd)
  222.     Use_lsof = ($2 == "is")
  223.     if (Progress)
  224.     printf "Checking for open pty masters:"
  225.     # Remove all ptys whose master is open from OpenPtys[]
  226.     NumOpen -= FindttyProcs(OpenPtys,Use_lsof,Progress)
  227.     if (!Quiet)
  228.     printf "%d open pty slave(s) whose master is not open.\n",NumOpen
  229.     if (NumOpen == 0)
  230.     return -1
  231.  
  232.     if (Progress)
  233.     printf "Finding processes on pty slaves:"
  234.  
  235.     #### This code is to be replaced
  236.     maxpty = -1
  237.     # Any ttys remaining in OpenPtys are those whose master side is not open
  238.     S = ""
  239.     for (pty in OpenPtys)
  240.     S = S " ttyp" pty
  241.     Cmd = "cd /dev; exec fuser " S " 2>&1"
  242.     if (Debug)
  243.     print ":" Cmd ":"
  244.     while ((ret = (Cmd | getline)) == 1) {
  245.     if (Debug)
  246.         print "\n" $0
  247.     # Only pay attention to ttys with processes
  248.     if ($1 ~ /^ttyp/) {
  249.         ttynum = substr($1,5)+0 
  250.         if (NF > 1 && $2 ~ /[0-9]/) {
  251.         if (ttynum > maxpty)
  252.             maxpty = ttynum
  253.         $1 = ""        # delete tty name
  254.         NotOpen("ttyp" ttynum,$0,Proc2TTYs)
  255.         if (Progress)
  256.             printf "+%s",ttynum
  257.         }
  258.         else {
  259.         # fuser found no processes for this slave even though crash
  260.         # reported it open.
  261.         if (Debug)
  262.             printf \
  263.         "\ncrash reports %s open but fuser finds no processes for it.\n",$1
  264.         if (Progress)
  265.             printf "-%s",ttynum
  266.         }
  267.     }
  268.     }
  269.     if (ret == -1) {
  270.     printf "Command '%s' failed.  Exiting.\n",Cmd > "/dev/stderr"
  271.     exit 1
  272.     }
  273.     close(Cmd)
  274.     if (Progress)
  275.     print ""
  276.     if (Debug)
  277.     printf "maxpty: %d",maxpty
  278.     #### End of code to be replaced
  279.  
  280.     return maxpty
  281. }
  282.  
  283. # Adds tty to the list of ttys that each process has open (Proc2TTYs[])
  284. function NotOpen(tty,ProcList,Proc2TTYs,  TTYProcs,pid) {
  285.     MakeSet(TTYProcs,ProcList," +")
  286.     for (pid in TTYProcs)
  287.     if (pid in Proc2TTYs)
  288.         Proc2TTYs[pid] = Proc2TTYs[pid] "," tty
  289.     else
  290.         Proc2TTYs[pid] = tty
  291. }
  292.  
  293. # Example crash session:
  294. #> tty -t spt
  295. #spt TABLE SIZE = 80
  296. #SLOT OUT RAW CAN DEL  PGRP STATE
  297. #   0   0   0   0   0 28898 isop carr islp
  298. #   1   0   0   0   0 24082 wtop isop
  299. #   2   0   0   0   0     0 isop
  300. #   3   0   0   0   0   930 isop carr islp ttxn
  301. #   4   0   0   0   0 28459 isop carr islp ttxn
  302. #   5   0   0   0   0   925 isop carr islp ttxn
  303. #   6   0   0   0   0   934 isop carr islp
  304. #   7   0   0   0   0 28965 isop carr islp ttxn
  305. #   8   0   0   0   0 29228 isop carr islp
  306. #   9   0   0   0   0 18200 isop carr
  307. #  10 220   0   0   0 29209 isop carr
  308. #  11   0   0   0   0 28239 isop carr
  309. #  12   1   0   0   0 28125 isop carr
  310. #  13   0   0   0   0 29493 isop carr
  311. #  14   0   0   0   0  4265 isop carr islp
  312. #  16   0   0   0   0 24807 isop carr
  313. #  17   0   2   0   1 25988 isop carr
  314. #  18   0   0   0   0 19728 wtop isop
  315. #  19   0   0   0   0 28048 isop carr
  316. #  20   0   0   0   0 22115 isop carr islp
  317. #  21   0   0   0   0 27688 isop carr islp rto
  318. #  22   0   0   0   0 22512 isop carr
  319. #  23   0   0   0   0     0 isop
  320. #  24   0   0   0   0 23127 isop carr
  321. #  25   0   0   0   0 28679 isop carr
  322. #  26   0   0   0   0 29528 isop carr
  323. #  27   0   0   0   0 24240 isop carr
  324. #  28   0   0   0   0 20162 isop carr islp
  325. #  30   0   0   0   0 28843 isop carr
  326. #  31   0   0   0   0 29256 isop carr
  327. #  32   0   0   0   0   605 isop carr
  328. # 
  329. # Puts a numeric index for each open pty in OpenPtys.
  330. # Returns number of pty slaves in use.
  331. function FindOpenPtySlaves(OpenPtys,  Cmd,Count,ret) {
  332.     Cmd = "echo tty -t spt | /etc/crash"
  333.     Count = 0    # Make sure a numeric value will be returned if none open
  334.     while ((Cmd | getline) == 1) {
  335.     if (Debug)
  336.         print $0
  337.     # tty num is $2 because FS has been set
  338.     if ($2 ~ /[0-9]/) {
  339.         OpenPtys[$2]
  340.         Count++
  341.     }
  342.     }
  343.     if (ret == -1) {
  344.     printf "Command '%s' failed.  Exiting.\n",Cmd > "/dev/stderr"
  345.     exit 1
  346.     }
  347.     close(Cmd)
  348.     return Count
  349. }
  350.  
  351. # MakeSet: make a set from a list.
  352. # An index with the name of each element of the list
  353. # is created in the given array.
  354. # Input variables: 
  355. # Elements is a string containing the list of elements.
  356. # Sep is the character that separates the elements of the list.
  357. # Output variables:
  358. # Set is the array.
  359. # Return value: the number of elements added to the set.
  360. function MakeSet(Set,Elements,Sep,  Num,Names) {
  361.     Num = split(Elements,Names,Sep)
  362.     for (; Num; Num--)
  363.     Set[Names[Num]]
  364.     return Num
  365. }
  366.  
  367. # Returns 1 if Set is empty, 0 if not.
  368. function IsEmpty(Set,  i) {
  369.     for (i in Set)
  370.     return 0
  371.     return 1
  372. }
  373.  
  374. function CopySet(From,To,  Elem) {
  375.     for (Elem in From)
  376.     To[Elem]
  377. }
  378.  
  379. ### Start of ProcArgs library
  380. # @(#) ProcArgs 1.11 96/12/08
  381. # 92/02/29 john h. dubois iii (john@armory.com)
  382. # 93/07/18 Added "#" arg type
  383. # 93/09/26 Do not count -h against MinArgs
  384. # 94/01/01 Stop scanning at first non-option arg.  Added ">" option type.
  385. #          Removed meaning of "+" or "-" by itself.
  386. # 94/03/08 Added & option and *()< option types.
  387. # 94/04/02 Added NoRCopt to Opts()
  388. # 94/06/11 Mark numeric variables as such.
  389. # 94/07/08 Opts(): Do not require any args if h option is given.
  390. # 95/01/22 Record options given more than once.  Record option num in argv.
  391. # 95/06/08 Added ExclusiveOptions().
  392. # 96/01/20 Let rcfiles be a colon-separated list of filenames.
  393. #          Expand $VARNAME at the start of its filenames.
  394. #          Let varname=0 and -option- turn off an option.
  395. # 96/05/05 Changed meaning of 7th arg to Opts; now can specify exactly how many
  396. #          of the vars should be searched for in the environment.
  397. #          Check for duplicate rcfiles.
  398. # 96/05/13 Return more specific error values.  Note: ProcArgs() and InitOpts()
  399. #          now return various negatives values on error, not just -1, and
  400. #          Opts() may set Err to various positive values, not just 1.
  401. #          Added AllowUnrecOpt.
  402. # 96/05/23 Check type given for & option
  403. # 96/06/15 Re-port to awk
  404. # 96/10/01 Moved file-reading code into ReadConfFile(), so that it can be
  405. #          used by other functions.
  406. # 96/10/15 Added OptChars
  407. # 96/11/01 Added exOpts arg to Opts()
  408. # 96/11/16 Added ; type
  409. # 96/12/08 Added Opt2Set() & Opt2Sets()
  410. # 96/12/27 Added CmdLineOpt()
  411.  
  412. # optlist is a string which contains all of the possible command line options.
  413. # A character followed by certain characters indicates that the option takes
  414. # an argument, with type as follows:
  415. # :    String argument
  416. # ;    Non-empty string argument
  417. # *    Floating point argument
  418. # (    Non-negative floating point argument
  419. # )    Positive floating point argument
  420. # #    Integer argument
  421. # <    Non-negative integer argument
  422. # >    Positive integer argument
  423. # The only difference the type of argument makes is in the runtime argument
  424. # error checking that is done.
  425.  
  426. # The & option is a special case used to get numeric options without the
  427. # user having to give an option character.  It is shorthand for [-+.0-9].
  428. # If & is included in optlist and an option string that begins with one of
  429. # these characters is seen, the value given to "&" will include the first
  430. # char of the option.  & must be followed by a type character other than ":"
  431. # or ";".
  432. # Note that if e.g. &> is given, an option of -.5 will produce an error.
  433.  
  434. # Strings in argv[] which begin with "-" or "+" are taken to be
  435. # strings of options, except that a string which consists solely of "-"
  436. # or "+" is taken to be a non-option string; like other non-option strings,
  437. # it stops the scanning of argv and is left in argv[].
  438. # An argument of "--" or "++" also stops the scanning of argv[] but is removed.
  439. # If an option takes an argument, the argument may either immediately
  440. # follow it or be given separately.
  441. # "-" and "+" options are treated the same.  "+" is allowed because most awks
  442. # take any -options to be arguments to themselves.  gawk 2.15 was enhanced to
  443. # stop scanning when it encounters an unrecognized option, though until 2.15.5
  444. # this feature had a flaw that caused problems in some cases.  See the OptChars
  445. # parameter to explicitly set the option-specifier characters.
  446.  
  447. # If an option that does not take an argument is given,
  448. # an index with its name is created in Options and its value is set to the
  449. # number of times it occurs in argv[].
  450.  
  451. # If an option that does take an argument is given, an index with its name is
  452. # created in Options and its value is set to the value of the argument given
  453. # for it, and Options[option-name,"count"] is (initially) set to the 1.
  454. # If an option that takes an argument is given more than once,
  455. # Options[option-name,"count"] is incremented, and the value is assigned to
  456. # the index (option-name,instance) where instance is 2 for the second occurance
  457. # of the option, etc.
  458. # In other words, the first time an option with a value is encountered, the
  459. # value is assigned to an index consisting only of its name; for any further
  460. # occurances of the option, the value index has an extra (count) dimension.
  461.  
  462. # The sequence number for each option found in argv[] is stored in
  463. # Options[option-name,"num",instance], where instance is 1 for the first
  464. # occurance of the option, etc.  The sequence number starts at 1 and is
  465. # incremented for each option, both those that have a value and those that
  466. # do not.  Options set from a config file have a value of 0 assigned to this.
  467.  
  468. # Options and their arguments are deleted from argv.
  469. # Note that this means that there may be gaps left in the indices of argv[].
  470. # If compress is nonzero, argv[] is packed by moving its elements so that
  471. # they have contiguous integer indices starting with 0.
  472. # Option processing will stop with the first unrecognized option, just as
  473. # though -- was given except that unlike -- the unrecognized option will not be
  474. # removed from ARGV[].  Normally, an error value is returned in this case.
  475. # If AllowUnrecOpt is true, it is not an error for an unrecognized option to
  476. # be found, so the number of remaining arguments is returned instead.
  477. # If OptChars is not a null string, it is the set of characters that indicate
  478. # that an argument is an option string if the string begins with one of the
  479. # characters.  A string consisting solely of two of the same option-indicator
  480. # characters stops the scanning of argv[].  The default is "-+".
  481. # argv[0] is not examined.
  482. # The number of arguments left in argc is returned.
  483. # If an error occurs, the global string OptErr is set to an error message
  484. # and a negative value is returned.
  485. # Current error values:
  486. # -1: option that required an argument did not get it.
  487. # -2: argument of incorrect type supplied for an option.
  488. # -3: unrecognized (invalid) option.
  489. function ProcArgs(argc,argv,OptList,Options,compress,AllowUnrecOpt,OptChars,
  490. ArgNum,ArgsLeft,Arg,ArgLen,ArgInd,Option,Pos,NumOpt,Value,HadValue,specGiven,
  491. NeedNextOpt,GotValue,OptionNum,Escape,dest,src,count,c,OptTerm,OptCharSet)
  492. {
  493. # ArgNum is the index of the argument being processed.
  494. # ArgsLeft is the number of arguments left in argv.
  495. # Arg is the argument being processed.
  496. # ArgLen is the length of the argument being processed.
  497. # ArgInd is the position of the character in Arg being processed.
  498. # Option is the character in Arg being processed.
  499. # Pos is the position in OptList of the option being processed.
  500. # NumOpt is true if a numeric option may be given.
  501.     ArgsLeft = argc
  502.     NumOpt = index(OptList,"&")
  503.     OptionNum = 0
  504.     if (OptChars == "")
  505.     OptChars = "-+"
  506.     while (OptChars != "") {
  507.     c = substr(OptChars,1,1)
  508.     OptChars = substr(OptChars,2)
  509.     OptCharSet[c]
  510.     OptTerm[c c]
  511.     }
  512.     for (ArgNum = 1; ArgNum < argc; ArgNum++) {
  513.     Arg = argv[ArgNum]
  514.     if (length(Arg) < 2 || !((specGiven = substr(Arg,1,1)) in OptCharSet))
  515.         break    # Not an option; quit
  516.     if (Arg in OptTerm) {
  517.         delete argv[ArgNum]
  518.         ArgsLeft--
  519.         break
  520.     }
  521.     ArgLen = length(Arg)
  522.     for (ArgInd = 2; ArgInd <= ArgLen; ArgInd++) {
  523.         Option = substr(Arg,ArgInd,1)
  524.         if (NumOpt && Option ~ /[-+.0-9]/) {
  525.         # If this option is a numeric option, make its flag be & and
  526.         # its option string flag position be the position of & in
  527.         # the option string.
  528.         Option = "&"
  529.         Pos = NumOpt
  530.         # Prefix Arg with a char so that ArgInd will point to the
  531.         # first char of the numeric option.
  532.         Arg = "&" Arg
  533.         ArgLen++
  534.         }
  535.         # Find position of flag in option string, to get its type (if any).
  536.         # Disallow & as literal flag.
  537.         else if (!(Pos = index(OptList,Option)) || Option == "&") {
  538.         if (AllowUnrecOpt) {
  539.             Escape = 1
  540.             break
  541.         }
  542.         else {
  543.             OptErr = "Invalid option: " specGiven Option
  544.             return -3
  545.         }
  546.         }
  547.  
  548.         # Find what the value of the option will be if it takes one.
  549.         # NeedNextOpt is true if the option specifier is the last char of
  550.         # this arg, which means that if the option requires a value it is
  551.         # the next arg.
  552.         if (NeedNextOpt = (ArgInd >= ArgLen)) { # Value is the next arg
  553.         if (GotValue = ArgNum + 1 < argc)
  554.             Value = argv[ArgNum+1]
  555.         }
  556.         else {    # Value is included with option
  557.         Value = substr(Arg,ArgInd + 1)
  558.         GotValue = 1
  559.         }
  560.  
  561.         if (HadValue = AssignVal(Option,Value,Options,
  562.         substr(OptList,Pos + 1,1),GotValue,"",++OptionNum,!NeedNextOpt,
  563.         specGiven)) {
  564.         if (HadValue < 0)    # error occured
  565.             return HadValue
  566.         if (HadValue == 2)
  567.             ArgInd++    # Account for the single-char value we used.
  568.         else {
  569.             if (NeedNextOpt) {    # option took next arg as value
  570.             delete argv[++ArgNum]
  571.             ArgsLeft--
  572.             }
  573.             break    # This option has been used up
  574.         }
  575.         }
  576.     }
  577.     if (Escape)
  578.         break
  579.     # Do not delete arg until after processing of it, so that if it is not
  580.     # recognized it can be left in ARGV[].
  581.     delete argv[ArgNum]
  582.     ArgsLeft--
  583.     }
  584.     if (compress != 0) {
  585.     dest = 1
  586.     src = argc - ArgsLeft + 1
  587.     for (count = ArgsLeft - 1; count; count--) {
  588.         ARGV[dest] = ARGV[src]
  589.         dest++
  590.         src++
  591.     }
  592.     }
  593.     return ArgsLeft
  594. }
  595.  
  596. # Assignment to values in Options[] occurs only in this function.
  597. # Option: Option specifier character.
  598. # Value: Value to be assigned to option, if it takes a value.
  599. # Options[]: Options array to return values in.
  600. # ArgType: Argument type specifier character.
  601. # GotValue: Whether any value is available to be assigned to this option.
  602. # Name: Name of option being processed.
  603. # OptionNum: Number of this option (starting with 1) if set in argv[],
  604. #     or 0 if it was given in a config file or in the environment.
  605. # SingleOpt: true if the value (if any) that is available for this option was
  606. #     given as part of the same command line arg as the option.  Used only for
  607. #     options from the command line.
  608. # specGiven is the option specifier character use, if any (e.g. - or +),
  609. # for use in error messages.
  610. # Global variables: OptErr
  611. # Return value: negative value on error, 0 if option did not require an
  612. # argument, 1 if it did & used the whole arg, 2 if it required just one char of
  613. # the arg.
  614. # Current error values:
  615. # -1: Option that required an argument did not get it.
  616. # -2: Value of incorrect type supplied for option.
  617. # -3: Bad type given for option &
  618. function AssignVal(Option,Value,Options,ArgType,GotValue,Name,OptionNum,
  619. SingleOpt,specGiven,  UsedValue,Err,NumTypes) {
  620.     # If option takes a value...    [
  621.     NumTypes = "*()#<>]"
  622.     if (Option == "&" && ArgType !~ "[" NumTypes) {    # ]
  623.     OptErr = "Bad type given for & option"
  624.     return -3
  625.     }
  626.  
  627.     if (UsedValue = (ArgType ~ "[:;" NumTypes)) {    # ]
  628.     if (!GotValue) {
  629.         if (Name != "")
  630.         OptErr = "Variable requires a value -- " Name
  631.         else
  632.         OptErr = "option requires an argument -- " Option
  633.         return -1
  634.     }
  635.     if ((Err = CheckType(ArgType,Value,Option,Name,specGiven)) != "") {
  636.         OptErr = Err
  637.         return -2
  638.     }
  639.     # Mark this as a numeric variable; will be propogated to Options[] val.
  640.     if (ArgType != ":" && ArgType != ";")
  641.         Value += 0
  642.     if ((Instance = ++Options[Option,"count"]) > 1)
  643.         Options[Option,Instance] = Value
  644.     else
  645.         Options[Option] = Value
  646.     }
  647.     # If this is an environ or rcfile assignment & it was given a value...
  648.     else if (!OptionNum && Value != "") {
  649.     UsedValue = 1
  650.     # If the value is "0" or "-" and this is the first instance of it,
  651.     # do not set Options[Option]; this allows an assignment in an rcfile to
  652.     # turn off an option (for the simple "Option in Options" test) in such
  653.     # a way that it cannot be turned on in a later file.
  654.     if (!(Option in Options) && (Value == "0" || Value == "-"))
  655.         Instance = 1
  656.     else
  657.         Instance = ++Options[Option]
  658.     # Save the value even though this is a flag
  659.     Options[Option,Instance] = Value
  660.     }
  661.     # If this is a command line flag and has a - following it in the same arg,
  662.     # it is being turned off.
  663.     else if (OptionNum && SingleOpt && substr(Value,1,1) == "-") {
  664.     UsedValue = 2
  665.     if (Option in Options)
  666.         Instance = ++Options[Option]
  667.     else
  668.         Instance = 1
  669.     Options[Option,Instance]
  670.     }
  671.     # If this is a flag assignment without a value, increment the count for the
  672.     # flag unless it was turned off.  The indicator for a flag being turned off
  673.     # is that the flag index has not been set in Options[] but it has an
  674.     # instance count.
  675.     else if (Option in Options || !((Option,1) in Options))
  676.     # Increment number of times this flag seen; will inc null value to 1
  677.     Instance = ++Options[Option]
  678.     Options[Option,"num",Instance] = OptionNum
  679.     return UsedValue
  680. }
  681.  
  682. # Option is the option letter
  683. # Value is the value being assigned
  684. # Name is the var name of the option, if any
  685. # ArgType is one of:
  686. # :    String argument
  687. # ;    Non-null string argument
  688. # *    Floating point argument
  689. # (    Non-negative floating point argument
  690. # )    Positive floating point argument
  691. # #    Integer argument
  692. # <    Non-negative integer argument
  693. # >    Positive integer argument
  694. # specGiven is the option specifier character use, if any (e.g. - or +),
  695. # for use in error messages.
  696. # Returns null on success, err string on error
  697. function CheckType(ArgType,Value,Option,Name,specGiven,  Err,ErrStr) {
  698.     if (ArgType == ":")
  699.     return ""
  700.     if (ArgType == ";") {
  701.     if (Value == "")
  702.         Err = "must be a non-empty string"
  703.     }
  704.     # A number begins with optional + or -, and is followed by a string of
  705.     # digits or a decimal with digits before it, after it, or both
  706.     else if (Value !~ /^[-+]?([0-9]+|[0-9]*\.[0-9]+|[0-9]+\.)$/)
  707.     Err = "must be a number"
  708.     else if (ArgType ~ "[#<>]" && Value ~ /\./)
  709.     Err = "may not include a fraction"
  710.     else if (ArgType ~ "[()<>]" && Value < 0)
  711.     Err = "may not be negative"
  712.     # (
  713.     else if (ArgType ~ "[)>]" && Value == 0)
  714.     Err = "must be a positive number"
  715.     if (Err != "") {
  716.     ErrStr = "Bad value \"" Value "\".  Value assigned to "
  717.     if (Name != "")
  718.         return ErrStr "variable " substr(Name,1,1) " " Err
  719.     else {
  720.         if (Option == "&")
  721.         Option = Value
  722.         return ErrStr "option " specGiven substr(Option,1,1) " " Err
  723.     }
  724.     }
  725.     else
  726.     return ""
  727. }
  728.  
  729. # Note: only the above functions are needed by ProcArgs.
  730. # The rest of these functions call ProcArgs() and also do other
  731. # option-processing stuff.
  732.  
  733. # Opts: Process command line arguments.
  734. # Opts processes command line arguments using ProcArgs()
  735. # and checks for errors.  If an error occurs, a message is printed
  736. # and the program is exited.
  737. #
  738. # Input variables:
  739. # Name is the name of the program, for error messages.
  740. # Usage is a usage message, for error messages.
  741. # OptList the option description string, as used by ProcArgs().
  742. # MinArgs is the minimum number of non-option arguments that this
  743. # program should have, non including ARGV[0] and +h.
  744. # If the program does not require any non-option arguments,
  745. # MinArgs should be omitted or given as 0.
  746. # rcFiles, if given, is a colon-seprated list of filenames to read for
  747. # variable initialization.  If a filename begins with ~/, the ~ is replaced
  748. # by the value of the environment variable HOME.  If a filename begins with
  749. # $, the part from the character after the $ up until (but not including)
  750. # the first character not in [a-zA-Z0-9_] will be searched for in the
  751. # environment; if found its value will be substituted, if not the filename will
  752. # be discarded.
  753. # rcfiles are read in the order given.
  754. # Values given in them will not override values given on the command line,
  755. # and values given in later files will not override those set in earlier
  756. # files, because AssignVal() will store each with a different instance index.
  757. # The first instance of each variable, either on the command line or in an
  758. # rcfile, will be stored with no instance index, and this is the value
  759. # normally used by programs that call this function.
  760. # VarNames is a comma-separated list of variable names to map to options,
  761. # in the same order as the options are given in OptList.
  762. # If EnvSearch is given and nonzero, the first EnvSearch variables will also be
  763. # searched for in the environment.  If set to -1, all values will be searched
  764. # for in the environment.  Values given in the environment will override
  765. # those given in the rcfiles but not those given on the command line.
  766. # NoRCopt, if given, is an additional letter option that if given on the
  767. # command line prevents the rcfiles from being read.
  768. # See ProcArgs() for a description of AllowUnRecOpt and optChars, and
  769. # ExclusiveOptions() for a description of exOpts.
  770. # Special options:
  771. # If x is made an option and is given, some debugging info is output.
  772. # h is assumed to be the help option.
  773.  
  774. # Global variables:
  775. # The command line arguments are taken from ARGV[].
  776. # The arguments that are option specifiers and values are removed from
  777. # ARGV[], leaving only ARGV[0] and the non-option arguments.
  778. # The number of elements in ARGV[] should be in ARGC.
  779. # After processing, ARGC is set to the number of elements left in ARGV[].
  780. # The option values are put in Options[].
  781. # On error, Err is set to a positive integer value so it can be checked for in
  782. # an END block.
  783. # Return value: The number of elements left in ARGV is returned.
  784. # Must keep OptErr global since it may be set by InitOpts().
  785. function Opts(Name,Usage,OptList,MinArgs,rcFiles,VarNames,EnvSearch,NoRCopt,
  786. AllowUnrecOpt,optChars,exOpts,  ArgsLeft,e) {
  787.     if (MinArgs == "")
  788.     MinArgs = 0
  789.     ArgsLeft = ProcArgs(ARGC,ARGV,OptList NoRCopt,Options,1,AllowUnrecOpt,
  790.     optChars)
  791.     if (ArgsLeft < (MinArgs+1) && !("h" in Options)) {
  792.     if (ArgsLeft >= 0) {
  793.         OptErr = "Not enough arguments"
  794.         Err = 4
  795.     }
  796.     else
  797.         Err = -ArgsLeft
  798.     printf "%s: %s.\nUse -h for help.\n%s\n",
  799.     Name,OptErr,Usage > "/dev/stderr"
  800.     exit 1
  801.     }
  802.     if (rcFiles != "" && (NoRCopt == "" || !(NoRCopt in Options)) &&
  803.     (e = InitOpts(rcFiles,Options,OptList,VarNames,EnvSearch)) < 0)
  804.     {
  805.     print Name ": " OptErr ".\nUse -h for help." > "/dev/stderr"
  806.     Err = -e
  807.     exit 1
  808.     }
  809.     if ((exOpts != "") && ((OptErr = ExclusiveOptions(exOpts,Options)) != ""))
  810.     {
  811.     printf "%s: Error: %s\n",Name,OptErr > "/dev/stderr"
  812.     Err = 1
  813.     exit 1
  814.     }
  815.     return ArgsLeft
  816. }
  817.  
  818. # ReadConfFile(): Read a file containing var/value assignments, in the form
  819. # <variable-name><assignment-char><value>.
  820. # Whitespace (spaces and tabs) around a variable (leading whitespace on the
  821. # line and whitespace between the variable name and the assignment character) 
  822. # is stripped.  Lines that do not contain an assignment operator or which
  823. # contain a null variable name are ignored, other than possibly being noted in
  824. # the return value.  If more than one assignment is made to a variable, the
  825. # first assignment is used.
  826. # Input variables:
  827. # File is the file to read.
  828. # Comment is the line-comment character.  If it is found as the first non-
  829. #     whitespace character on a line, the line is ignored.
  830. # Assign is the assignment string.  The first instance of Assign on a line
  831. #     separates the variable name from its value.
  832. # If StripWhite is true, whitespace around the value (whitespace between the
  833. #     assignment char and trailing whitespace on the line) is stripped.
  834. # VarPat is a pattern that variable names must match.  
  835. #     Example: "^[a-zA-Z][a-zA-Z0-9]+$"
  836. # If FlagsOK is true, variables are allowed to be "set" by being put alone on
  837. #     a line; no assignment operator is needed.  These variables are set in
  838. #     the output array with a null value.  Lines containing nothing but
  839. #     whitespace are still ignored.
  840. # Output variables:
  841. # Values[] contains the assignments, with the indexes being the variable names
  842. #     and the values being the assigned values.
  843. # Lines[] contains the line number that each variable occured on.  A flag set
  844. #     is record by giving it an index in Lines[] but not in Values[].
  845. # Return value:
  846. # If any errors occur, a string consisting of descriptions of the errors
  847. # separated by newlines is returned.  In no case will the string start with a
  848. # numeric value.  If no errors occur,  the number of lines read is returned.
  849. function ReadConfigFile(Values,Lines,File,Comment,Assign,StripWhite,VarPat,
  850. FlagsOK,
  851. Line,Status,Errs,AssignLen,LineNum,Var,Val) {
  852.     if (Comment != "")
  853.     Comment = "^" Comment
  854.     AssignLen = length(Assign)
  855.     if (VarPat == "")
  856.     VarPat = "."    # null varname not allowed
  857.     while ((Status = (getline Line < File)) == 1) {
  858.     LineNum++
  859.     sub("^[ \t]+","",Line)
  860.     if (Line == "")        # blank line
  861.         continue
  862.     if (Comment != "" && Line ~ Comment)
  863.         continue
  864.     if (Pos = index(Line,Assign)) {
  865.         Var = substr(Line,1,Pos-1)
  866.         Val = substr(Line,Pos+AssignLen)
  867.         if (StripWhite) {
  868.         sub("^[ \t]+","",Val)
  869.         sub("[ \t]+$","",Val)
  870.         }
  871.     }
  872.     else {
  873.         Var = Line    # If no value, var is entire line
  874.         Val = ""
  875.     }
  876.     if (!FlagsOK && Val == "") {
  877.         Errs = Errs \
  878.         sprintf("\nBad assignment on line %d of file %s: %s",
  879.         LineNum,File,Line)
  880.         continue
  881.     }
  882.     sub("[ \t]+$","",Var)
  883.     if (Var !~ VarPat) {
  884.         Errs = Errs sprintf("\nBad variable name on line %d of file %s: %s",
  885.         LineNum,File,Var)
  886.         continue
  887.     }
  888.     if (!(Var in Lines)) {
  889.         Lines[Var] = LineNum
  890.         if (Pos)
  891.         Values[Var] = Val
  892.     }
  893.     }
  894.     if (Status)
  895.     Errs = Errs "\nCould not read file " File
  896.     close(File)
  897.     return Errs == "" ? LineNum : substr(Errs,2)    # Skip first newline
  898. }
  899.  
  900. # Variables:
  901. # Data is stored in Options[].
  902. # rcFiles, OptList, VarNames, and EnvSearch are as as described for Opts().
  903. # Global vars:
  904. # Sets OptErr.  Uses ENVIRON[].
  905. # If anything is read from any of the rcfiles, sets READ_RCFILE to 1.
  906. function InitOpts(rcFiles,Options,OptList,VarNames,EnvSearch,
  907. Line,Var,Pos,Vars,Map,CharOpt,NumVars,TypesInd,Types,Type,Ret,i,rcFile,
  908. fNames,numrcFiles,filesRead,Err,Values,retStr) {
  909.     split("",filesRead,"")    # make awk know this is an array
  910.     NumVars = split(VarNames,Vars,",")
  911.     TypesInd = Ret = 0
  912.     if (EnvSearch == -1)
  913.     EnvSearch = NumVars
  914.     for (i = 1; i <= NumVars; i++) {
  915.     Var = Vars[i]
  916.     CharOpt = substr(OptList,++TypesInd,1)
  917.     if (CharOpt ~ "^[:;*()#<>&]$")
  918.         CharOpt = substr(OptList,++TypesInd,1)
  919.     Map[Var] = CharOpt
  920.     Types[Var] = Type = substr(OptList,TypesInd+1,1)
  921.     # Do not overwrite entries from environment
  922.     if (i <= EnvSearch && Var in ENVIRON &&
  923.     (Err = AssignVal(CharOpt,ENVIRON[Var],Options,Type,1,Var,0)) < 0)
  924.         return Err
  925.     }
  926.  
  927.     numrcFiles = split(rcFiles,fNames,":")
  928.     for (i = 1; i <= numrcFiles; i++) {
  929.     rcFile = fNames[i]
  930.     if (rcFile ~ "^~/")
  931.         rcFile = ENVIRON["HOME"] substr(rcFile,2)
  932.     else if (rcFile ~ /^\$/) {
  933.         rcFile = substr(rcFile,2)
  934.         match(rcFile,"^[a-zA-Z0-9_]*")
  935.         envvar = substr(rcFile,1,RLENGTH)
  936.         if (envvar in ENVIRON)
  937.         rcFile = ENVIRON[envvar] substr(rcFile,RLENGTH+1)
  938.         else
  939.         continue
  940.     }
  941.     if (rcFile in filesRead)
  942.         continue
  943.     # rcfiles are liable to be given more than once, e.g. UHOME and HOME
  944.     # may be the same
  945.     filesRead[rcFile]
  946.     if ("x" in Options)
  947.         printf "Reading configuration file %s\n",rcFile > "/dev/stderr"
  948.     retStr = ReadConfigFile(Values,Lines,rcFile,"#","=",0,"",1)
  949.     if (retStr > 0)
  950.         READ_RCFILE = 1
  951.     else if (ret != "") {
  952.         OptErr = retStr
  953.         Ret = -1
  954.     }
  955.     for (Var in Lines)
  956.         if (Var in Map) {
  957.         if ((Err = AssignVal(Map[Var],
  958.         Var in Values ? Values[Var] : "",Options,Types[Var],
  959.         Var in Values,Var,0)) < 0)
  960.             return Err
  961.         }
  962.         else {
  963.         OptErr = sprintf(\
  964.         "Unknown var \"%s\" assigned to on line %d\nof file %s",Var,
  965.         Lines[Var],rcFile)
  966.         Ret = -1
  967.         }
  968.     }
  969.  
  970.     if ("x" in Options)
  971.     for (Var in Map)
  972.         if (Map[Var] in Options)
  973.         printf "(%s) %s=%s\n",Map[Var],Var,Options[Map[Var]] > \
  974.         "/dev/stderr"
  975.         else
  976.         printf "(%s) %s not set\n",Map[Var],Var > "/dev/stderr"
  977.     return Ret
  978. }
  979.  
  980. # OptSets is a semicolon-separated list of sets of option sets.
  981. # Within a list of option sets, the option sets are separated by commas.  For
  982. # each set of sets, if any option in one of the sets is in Options[] AND any
  983. # option in one of the other sets is in Options[], an error string is returned.
  984. # If no conflicts are found, nothing is returned.
  985. # Example: if OptSets = "ab,def,g;i,j", an error will be returned due to
  986. # the exclusions presented by the first set of sets (ab,def,g) if:
  987. # (a or b is in Options[]) AND (d, e, or f is in Options[]) OR
  988. # (a or b is in Options[]) AND (g is in Options) OR
  989. # (d, e, or f is in Options[]) AND (g is in Options)
  990. # An error will be returned due to the exclusions presented by the second set
  991. # of sets (i,j) if: (i is in Options[]) AND (j is in Options[]).
  992. # todo: make options given on command line unset options given in config file
  993. # todo: that they conflict with.
  994. function ExclusiveOptions(OptSets,Options,
  995. Sets,SetSet,NumSets,Pos1,Pos2,Len,s1,s2,c1,c2,ErrStr,L1,L2,SetSets,NumSetSets,
  996. SetNum,OSetNum) {
  997.     NumSetSets = split(OptSets,SetSets,";")
  998.     # For each set of sets...
  999.     for (SetSet = 1; SetSet <= NumSetSets; SetSet++) {
  1000.     # NumSets is the number of sets in this set of sets.
  1001.     NumSets = split(SetSets[SetSet],Sets,",")
  1002.     # For each set in a set of sets except the last...
  1003.     for (SetNum = 1; SetNum < NumSets; SetNum++) {
  1004.         s1 = Sets[SetNum]
  1005.         L1 = length(s1)
  1006.         for (Pos1 = 1; Pos1 <= L1; Pos1++)
  1007.         # If any of the options in this set was given, check whether
  1008.         # any of the options in the other sets was given.  Only check
  1009.         # later sets since earlier sets will have already been checked
  1010.         # against this set.
  1011.         if ((c1 = substr(s1,Pos1,1)) in Options)
  1012.             for (OSetNum = SetNum+1; OSetNum <= NumSets; OSetNum++) {
  1013.             s2 = Sets[OSetNum]
  1014.             L2 = length(s2)
  1015.             for (Pos2 = 1; Pos2 <= L2; Pos2++)
  1016.                 if ((c2 = substr(s2,Pos2,1)) in Options)
  1017.                 ErrStr = ErrStr "\n"\
  1018.                 sprintf("Cannot give both %s and %s options.",
  1019.                 c1,c2)
  1020.             }
  1021.     }
  1022.     }
  1023.     if (ErrStr != "")
  1024.     return substr(ErrStr,2)
  1025.     return ""
  1026. }
  1027.  
  1028. # The value of each instance of option Opt that occurs in Options[] is made an
  1029. # index of Set[].
  1030. # The return value is the number of instances of Opt in Options.
  1031. function Opt2Set(Options,Opt,Set,  count) {
  1032.     if (!(Opt in Options))
  1033.     return 0
  1034.     Set[Options[Opt]]
  1035.     count = Options[Opt,"count"]
  1036.     for (; count > 1; count--)
  1037.     Set[Options[Opt,count]]
  1038.     return count
  1039. }
  1040.  
  1041. # The value of each instance of option Opt that occurs in Options[] that
  1042. # begins with "!" is made an index of nSet[] (with the ! stripped from it).
  1043. # Other values are made indexes of Set[].
  1044. # The return value is the number of instances of Opt in Options.
  1045. function Opt2Sets(Options,Opt,Set,nSet,  count,aSet,ret) {
  1046.     ret = Opt2Set(Options,Opt,aSet)
  1047.     for (value in aSet)
  1048.     if (substr(value,1,1) == "!")
  1049.         nSet[substr(value,2)]
  1050.     else
  1051.         Set[value]
  1052.     return ret
  1053. }
  1054.  
  1055. # Returns true if option Opt was given on the command line.
  1056. function CmdLineOpt(Options,Opt,  i) {
  1057.     for (i = 1; (Opt,"num",i) in Options; i++)
  1058.     if (Options[Opt,"num",i] != 0)
  1059.         return 1
  1060.     return 0
  1061. }
  1062. ### End of ProcArgs library
  1063.